<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
  <title>Construct Unit test file | Core</title>
  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
  <script type="text/javascript" charset="utf-8">
    var eventResults = {};
    var originalElement = window.Element;
  </script>
  <script src="../../lib/prototype.js" type="text/javascript"></script>
  <script src="../../lib/unittest.js" type="text/javascript"></script>
  <link rel="stylesheet" href="../../test.css" type="text/css" />
  <script type="text/javascript">
/*------------------------------- Begin Test Code ---------------------------*/

/**
 * @projectDescription
 * Construct Javascript Framework :: Building A Better Web
 * 
 * Much of this framework has been adapted from or inspired by the excellent: 
 *   Prototype <http://www.prototypejs.org>, 
 *   jQuery    <http://jquery.com>, and
 *   Mootools  <http://mootools.net/> 
 * frameworks (which are all available under the MIT license). The creators 
 * and contributors of these frameworks rock and without them, Construct 
 * (and the web as we know it) wouldn't exist. Comments, feeback, bugs and 
 * donations (all of which are greatly appreciated) should be directed to the 
 * Construct website: <http://constructjs.org>.
 * 
 * @version 0.1.0.0
 * @author Brent Broome
 * @copyright 2008, Brent Broome
 * @license MIT <http://www.opensource.org/licenses/mit-license.php>
 */

// $, Element and Event are the only global variables we define (and the 
// latter two only get defined if they're not native in the browser)
var 

/**
 * This is the core Construct object, which happens to also be the familiar $ 
 * function. If you pass it a String, it returns the Element in the document 
 * with the matching id (or null if no such Element exists). If you pass it a 
 * native DOM node, it returns it wrapped in an Element. If you pass it an 
 * Element, it returns it unchanged. If you pass it multiple arguments, it
 * returns an Array of Elements, one for each String, node or Element in the
 * original Array.
 * 
 * @see Element
 * @param {String,Element} element The element id, native DOM node or existing
 *  Element to wrap in an Element and return. If multiple arguements are 
 *  provided, they are all wrapped and returned in an Array.
 * @return {Element} The wrapped Element (or Array of Elements)
 * @since 0.1
 */
_C = function(element) 
{
  var i, elements = [], length = arguments.length; 
   
  if (length > 1) {
    for (i = 0; i < length; i++) 
      elements.push(_C(arguments[i]));
      
    return elements;
  }  
  
  if (typeof element == 'string')
    element = document.getElementById(element);    
    
  return Element.extend(element);
},

/**
 * This object wraps native DOM nodes (those things returned by native
 * functions such as document.getElementById) and provides simple,
 * efficient, cross-browser methods for querying and manipulating them. 
 * @since 0.1
 */
Element = window.Element || {},

/**
 * This object wraps native event objects and provides simple,
 * efficient, cross-browser methods for querying and manipulating them. 
 * @since 0.1
 */
Event = window.Event || {};

  
/**
 * The current version of the framework, formatted as:
 * 'major,minor,revision,build', which are incremented as follows:
 * 
 *   major   : When there are major changes made to the architecture, 
 *             stability or scope of the framework
 *   minor   : When there is a change made to the API of the framework,
 *             such as adding or removing classes or methods, changing
 *             arguments, deprecating existing methods, etc. 
 *   revision: When a new version of the framework is released without
 *             any changes to the API (i.e. bug fix releases).
 *   build   : When ANY change is made to the framework (this is only 
 *             used internally for development and will always be 0
 *             for public releases)
 *             
 * Note: Incrementing any of the values zeros-out the values to its right.
 * @alias $.Version
 * @since 0.1
 */
_C.Version = '0.1.0.0';

/**
 * An empty function, provided for convenience and clarity
 * @since 0.1
 */
_C.EmptyFn = function() {};

/**
 * The identity function, which returns its argument unchanged
 * @param  {Object} x The object to return
 * @return {Object} The object passed as the argument
 * @since 0.1
 */
_C.IdFn = function(x) { return x; };
  
/**
 * Adds all of the properties in source to destination (overwriting
 * them if they already exist) and returns destination.
 * @param {Object} destination The object to extend.
 * @param {Object} source      The object from which to extend.
 * @return {Object} destination, extended with all the properties in source
 * @since 0.1
 */
_C.extend = function(destination, source) 
{
  for (var property in source) 
    destination[property] = source[property];  
   
  return destination;
};

/*
 * Wrap all other code in a monolithic anonymous function to allow the
 * definition of variables during the initialization of the framework
 * (for simplicity, efficiency and mungeability) without poluting the
 * global namespace.
 */
(function() {  // begin global wrapper

/**<class.js>**/

/**<function.js>**/

/**<utils.js>**/

/**<string.js>**/

/**<number.js>**/

/**<enumerable.js>**/

/**<array.js>**/

/**<hash.js>**/

/**<range.js>**/

/**<browsers.js>**/

/**<elementCore.js>**/

/**<elementStyles.js>**/

/**<elementUtils.js>**/

/**<selector.js>**/

/**<form.js>**/

/**<event.js>**/

/**<ajax.js>**/

/**<fx.js>**/

// Ensure the $ function works even if the Element module isn't included
if(!Element.extend) 
  Element.extend = _C.IdFn;   

})(); // end global wrapper

/*-------------------------------- End Test Code ----------------------------*/
/*----------------------------- Begin Test Fixtures -------------------------*/

var _fixtureVersion = '0.1.0.0'

/*------------------------------ End Test Fixtures --------------------------*/
  </script>
  <script src="../coreTest.js" type="text/javascript" charset="utf-8"></script>
</head>
<body>
<h1>Construct Unit test file</h1>
<h2>Core</h2>

<!-- This file is programmatically generated. Do not attempt to modify it. Instead, modify  -->

<!-- Log output start -->
<div id="testlog"></div>
<!-- Log output end -->

<!-- HTML Fixtures start -->
<div id="hardCandyShell">a rich, chocolaty center</div>
<p id="aLinkToHere" style="visibility: hidden">Go <a href="#">here</a></p>
<ul id="list" style="display:none">
  <li></li>
  <li></li>
  <li></li>
</ul>
<!-- HTML Fixtures end -->
</body>
</html>
<script type="text/javascript" charset="utf-8">
  eventResults.endOfDocument = true;
</script>
